package cn.js.sangu.unitStore.service.process;

import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
import java.util.function.Function;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import cn.hutool.core.util.StrUtil;
import cn.js.sangu.unitStore.entity.ExcelData;
import cn.js.sangu.unitStore.mapper.ExcelDataMapper;
import lombok.extern.slf4j.Slf4j;

@Slf4j
@Service
public class MarkDuplicateCodes {

    @Autowired
    ExcelDataMapper excelDataMapper;

    public void mainCommonByTable(String tableSuffix) {
        // 原有bianma查重逻辑
        processDuplicateField(tableSuffix, "bianma", 
            data -> data.getBianma(),
            (table, dataList) -> {
                if ("11".equals(table)) {
                    excelDataMapper.batchUpdateShuchuBy11(dataList);
                } else {
                    excelDataMapper.batchUpdateShuchuBy12(dataList);
                }
            },
            "编码", "shuchu");
    
        // 新增syscode查重逻辑
        processDuplicateField(tableSuffix, "syscode", 
            data -> data.getSyscode(),
            (table, dataList) -> {
                if ("11".equals(table)) {
                    excelDataMapper.batchUpdateRemarkBy11(dataList);
                } else {
                    excelDataMapper.batchUpdateRemarkBy12(dataList);
                }
            },
            "自动编码", "remark");
    }

    // 新增通用查重处理方法
    private void processDuplicateField(String tableSuffix, String fieldName,
        Function<ExcelData, String> fieldGetter,
        BiConsumer<String, List<ExcelData>> batchUpdater,
        String fieldChineseName, String targetField) {
        // 查询重复数据（保持原有空值过滤逻辑）
        List<ExcelData> duplicateDataList = getDuplicateDataList(tableSuffix, fieldName);
        List<ExcelData> updatedDataList = new ArrayList<>();
        for (ExcelData data : duplicateDataList) {
            String fieldValue = fieldGetter.apply(data);
            if (StrUtil.isBlank(fieldValue)) {
                log.debug("跳过空{}记录，ID：{}", fieldChineseName, data.getId());
                continue;
            }
            List<ExcelData> allDuplicateData = getAllDuplicates(tableSuffix, fieldName, fieldValue);
            if (allDuplicateData.size() < 2) continue;
            StringBuilder systemBuilder = buildDuplicateInfo(data, allDuplicateData);
            if (systemBuilder.length() > 0) {
                setDuplicateRemark(data, targetField, fieldChineseName, systemBuilder);
                updatedDataList.add(data);
            }
        }
        if (!updatedDataList.isEmpty()) {
            batchUpdater.accept(tableSuffix, updatedDataList);
            log.info("批量标记重复{}完成，更新数量：{}，表后缀：{}", fieldChineseName, updatedDataList.size(), tableSuffix);
        }
    }

    // 新增：获取重复数据列表的通用方法
    private List<ExcelData> getDuplicateDataList(String tableSuffix, String fieldName) {
        return "11".equals(tableSuffix) ? 
        ("bianma".equals(fieldName) ? 
        excelDataMapper.findDuplicateCodesBy11() : 
        excelDataMapper.findDuplicateSyscodesBy11()) :
        ("bianma".equals(fieldName) ? 
        excelDataMapper.findDuplicateCodesBy12() : 
        excelDataMapper.findDuplicateSyscodesBy12());
    }

    // 新增：获取所有重复记录的通用方法
    private List<ExcelData> getAllDuplicates(String tableSuffix, String fieldName, String fieldValue) {
        return "11".equals(tableSuffix) ? 
        ("bianma".equals(fieldName) ? 
        excelDataMapper.findByCodeBy11(fieldValue) : 
        excelDataMapper.findBySyscodeBy11(fieldValue)) :
        ("bianma".equals(fieldName) ? 
        excelDataMapper.findByCodeBy12(fieldValue) : 
        excelDataMapper.findBySyscodeBy12(fieldValue));
    }

    // 新增：构建重复信息的通用方法
    private StringBuilder buildDuplicateInfo(ExcelData data, List<ExcelData> allDuplicateData) {
        StringBuilder systemBuilder = new StringBuilder();
        for (ExcelData dupData : allDuplicateData) {
            if (!dupData.getId().equals(data.getId())) {
                if (systemBuilder.length() > 0) {
                    systemBuilder.append("、");
                }
                systemBuilder.append("ID为").append(dupData.getId());
            }
        }
        return systemBuilder;
    }

    // 新增：设置重复备注的通用方法
    private void setDuplicateRemark(ExcelData data, String targetField, 
    String fieldChineseName, StringBuilder systemBuilder) {
        String remark = "与" + systemBuilder.toString() + "的‘" + fieldChineseName + "’重复";
        if ("shuchu".equals(targetField)) {
            data.setShuchu(remark);
        } else {
            data.setRemark(remark);
        }
        log.debug("标记重复{}[{}]，ID：{}", fieldChineseName, data.getSyscode(), data.getId());
    }

    // private void markDuplicateCodes(String tableSuffix) {
    //     // 查询重复编码数据时过滤空编码（关键优化：避免空编码被误判）
    //     List<ExcelData> duplicateDataList = "11".equals(tableSuffix) ? 
    //         excelDataMapper.findDuplicateCodesBy11() : excelDataMapper.findDuplicateCodesBy12();
    //     List<ExcelData> updatedDataList = new ArrayList<>();

    //     for (ExcelData data : duplicateDataList) {
    //         String bianma = data.getBianma();
    //         // 新增：空编码直接跳过（避免无效处理）
    //         if (StrUtil.isBlank(bianma)) {
    //             log.debug("跳过空物料编码记录，ID：{}", data.getId());
    //             continue;
    //         }

    //         // 查询所有相同编码的记录（包含自身）
    //         List<ExcelData> allDuplicateData = "11".equals(tableSuffix) ? 
    //             excelDataMapper.findByCodeBy11(bianma) : excelDataMapper.findByCodeBy12(bianma);
            
    //         // 新增：至少2条记录才视为重复（避免自身重复）
    //         if (allDuplicateData.size() < 2) {
    //             log.debug("物料编码[{}]无重复记录，ID：{}", bianma, data.getId());
    //             continue;
    //         }

    //         // 构建重复提示信息（优化：包含具体编码值）
    //         StringBuilder systemBuilder = new StringBuilder();
    //         for (ExcelData dupData : allDuplicateData) {
    //             if (!dupData.getId().equals(data.getId())) { // 排除自身
    //                 if (systemBuilder.length() > 0) {
    //                     systemBuilder.append("、");
    //                 }
    //                 systemBuilder.append("ID为").append(dupData.getId());
    //             }
    //         }

    //         if (systemBuilder.length() > 0) {
    //             // 优化提示信息：包含具体编码值
    //             data.setShuchu("与" + systemBuilder.toString() + "的‘物料编码’重复");
    //             updatedDataList.add(data);
    //             log.debug("标记重复编码[{}]，ID：{}", bianma, data.getId());
    //         }
    //     }

    //     // 批量更新（保留原有逻辑）
    //     if (!updatedDataList.isEmpty()) {
    //         if ("11".equals(tableSuffix)) {
    //             excelDataMapper.batchUpdateShuchuBy11(updatedDataList);
    //         } else {
    //             excelDataMapper.batchUpdateShuchuBy12(updatedDataList);
    //         }
    //         log.info("批量标记重复code完成，更新数量：{}，表后缀：{}", updatedDataList.size(), tableSuffix);
    //     } else {
    //         log.info("未发现需要标记的重复code，表后缀：{}", tableSuffix);
    //     }
    // }
}
